/**
* \file		TabTerrains.c
* \brief	Code des fonctions du module TabTerrain
* \details	C'est ici qu'est le code des accesseurs, mutateurs ainsi que
*		la fonction de test vérifant le bon fonctionnement du module
*		TabTerrain.
*/

/* voir si on garde tous les includes */
#include "TabTerrains.h"
#include <stdlib.h>
#include <assert.h>
#include <string.h>

/*============== Gestion de la mémoire / Création du tableau ==============*/
void initTabTerrains(TabTerrains *ptabTerrains, FILE *f)
{
   int verifRecup;
   int i;
   int nbCases = ptabTerrains->nbCases;

   /* variables permettant de stocker temporairement les données du fichier */
   char nom[100];
   char repres[100];
   int cultivable;
   int traversable;
   int surface;

   for(i=0; i<nbCases; i++)
	{
	   verifRecup = fscanf(f, "%s\n%s\n%d\n%d\n%d\n\n", nom, repres, &cultivable, &traversable, &surface);
	   assert(verifRecup == 5);

	/* création du terrain i du tableau */
	   ptabTerrains->tabTerr[i] = creerTerrain(nom, repres);
	   setCultivableTerrain(&ptabTerrains->tabTerr[i], cultivable);
	   setTraversableTerrain(&ptabTerrains->tabTerr[i], traversable);
	   setTerrainDeSurface(&ptabTerrains->tabTerr[i], surface);
	}

}

TabTerrains creerTabTerrains(char *fichierData)
{
   TabTerrains tabTerrRes;
   int verifRecup;
   int nbCases;

   FILE* f;
   /* bricolage de l'adresse du fichier à partir de la racine */
   char adresse[100] = {"./data/"};
   strcat(adresse, fichierData);

   /* récupération des données du fichier */
   f = fopen(adresse, "r");
   if(f == NULL)
	{
	   printf("Erreur lors de l'ouverture du fichier de données des terrains.\n");
	   assert(f);
	}

   verifRecup = fscanf(f, "%d\n\n", &nbCases);
   assert(verifRecup == 1);

   tabTerrRes.tabTerr = (Terrain*)malloc((nbCases)*sizeof(Terrain));

   setNbCasesTabTerrains(&tabTerrRes, nbCases);
   initTabTerrains(&tabTerrRes, f);

   fclose(f);
   return tabTerrRes;
}

void detruireTabTerrains(TabTerrains *ptabTerrains)
{
   int i;

   for(i=0; i<ptabTerrains->nbCases; i++)
	{
	   detruireTerrain(&ptabTerrains->tabTerr[i]);
	}
   free(ptabTerrains->tabTerr);
}

/*============================= Accesseurs =============================*/
int getNbCasesTabTerrains(const TabTerrains *ptabTerrains)
{
   int res = ptabTerrains->nbCases;
   assert(res >=0);
   return res;
}

Terrain *getTerrainTabTerrains(const TabTerrains *ptabTerrains, int indiceCase)
{
   assert((indiceCase >=0)&&(indiceCase < getNbCasesTabTerrains(ptabTerrains)));
   return &ptabTerrains->tabTerr[indiceCase];
}

/*============================= Mutateurs =============================*/
void setNbCasesTabTerrains(TabTerrains *ptabTerrains, int nouvNbCases)
{
   assert(nouvNbCases >= 0);
   ptabTerrains->nbCases = nouvNbCases;
}


/*=============================== Autres ===============================*/
Terrain *rechercheTabTerrains(const TabTerrains *ptabTerrains, const char *nomTerr)
{
   Terrain *res;
   int existe = 0;
   int i;

   for(i=0; i<ptabTerrains->nbCases; i++)
	{
	   if(strcmp(nomTerr, ptabTerrains->tabTerr[i].nom)==0)
		{
		   existe = 1;
		   res = &ptabTerrains->tabTerr[i];
		}
	}
   assert(existe !=0);
   return res;
}


/*=========================== Fonctions de Test ===========================*/
void testTabTerrains()
{
   char *fichierDat = {"DatTerr"};
   char aChercher[][20] = {"sable", "eau", "terreSout", "terreSurf", "grotte"};
   int i;
   TabTerrains tableau;
   Terrain trouvaille;

   printf("Test de TabTerrains\n");

   tableau = creerTabTerrains(fichierDat);

   printf("\tCréation du tableau et recherche d'éléments\t");
   for(i=0; i<5; i++)
	{
	   trouvaille = (*rechercheTabTerrains(&tableau, aChercher[i]));
	   assert(strcmp(trouvaille.nom, aChercher[i]) == 0);
	}
   printf("OK\n\n");

   detruireTabTerrains(&tableau);
}

